Method and system for administration of storage objects

ABSTRACT

An exemplary embodiment of the present invention provides a method of generating a representation of a storage network. The method includes generating a tree model representation of a storage network, the tree model comprising a plurality of nodes, wherein each node represents a portion of the storage network currently being displayed on a display device. The method also includes receiving a request from a client system to view contents of a node in the tree model. The method also includes, in response to the request, obtaining tree information for the node in the request, the tree information related to an additional portion of the storage network not being displayed. The method also includes adding an additional node to the tree model based on the tree information and displaying the additional portion of the storage network that is represented by the additional node.

CROSS-REFERENCE TO RELATED APPLICATION

This application is a continuation of co-pending U.S. patent applicationSer. No. 12/548,869, filed Aug. 27, 2009, the entire contents of whichare hereby incorporated by reference as though fully set forth herein.

BACKGROUND

A business network may include large number of storage objects, such asmultiple disk arrays, network-attached storage (NAS) devices, and thelike. Moreover, a large network may contain thousands of storagedevices. To provide a client system access to the storage network, thestorage network may be represented graphically to the client system inthe form of a hierarchical tree of folders and subfolders. The clientsystem may view, navigate, and manage all of the folders and filesincluded in the tree.

Typically, an image of the network will be created and maintained by acentral server that acquires information from each storage device in thenetwork. The server aggregates all of the storage devices in the networkinto a single tree model representing the entire network. Maintainingthe tree model for the entire network may use significant processingresources.

BRIEF DESCRIPTION OF THE DRAWINGS

Certain exemplary embodiments are described in the following detaileddescription and in reference to the drawings, in which:

FIG. 1 is a block diagram of a storage network in which a client systemcan access storage devices through a server, in accordance withexemplary embodiments of the present invention;

FIG. 2 is a process flow diagram of a method of generating the storagetree model, in accordance with exemplary embodiments of the presentinvention;

FIG. 3 is a graphical representation of an initial tree table, inaccordance with exemplary embodiments of the present invention;

FIG. 4 is a graphical representation of the tree table after additionalnodes have been accessed by the client, in accordance with exemplaryembodiments of the present invention;

FIG. 5 is a process flow diagram of a method of updating the storagetree model, in accordance with exemplary embodiments of the presentinvention;

FIG. 6 is graphical representation of tree table of FIG. 3 after somenodes have been changed, in accordance with exemplary embodiments of thepresent invention; and

FIG. 7 is a block diagram of a tangible, machine-readable medium, inaccordance with an embodiment of the present invention.

DETAILED DESCRIPTION OF SPECIFIC EMBODIMENTS

Exemplary embodiments of the present invention provide techniques fordisplaying a large number of objects in a hierarchical tree, whilereducing the processing resources used by the server that maintains thetree. In exemplary embodiments of the present invention, the serveraccesses and updates those parts of the storage tree that are currentlybeing viewed by a client system and adds those parts of the tree to atree model. As used herein, the term “tree model” refers to therepresentation of the storage network that is stored on the server andused to generate the graphical representation of the storage networkthat is displayed to a client.

The storage network may include several root nodes or tree sources fromwhich the tree model may be generated. Changes to the files or treestructure of any particular tree source may cause the tree source tosend an event to the server that causes the server to update the treemodel. In this way, the server retrieves information about nodes thathave potentially changed and are actively being viewed by a clientsystem. Thus, the server may generate a smaller tree model that may notinclude network resources that are not being accessed by a client, andthe processing resources devoted to maintaining the tree model may bereduced.

FIG. 1 is a block diagram of a storage network in which a client systemcan access storage devices through a server, in accordance withexemplary embodiments of the present invention. As illustrated in FIG.1, a storage network 100 will generally include client system 102 and aserver 104. In some exemplary embodiments of the present inventions, thenetwork 100 may be a peer-to-peer network and may include a plurality ofservers 104 and clients 102. The client system 102 may be any kind ofgeneral purpose computing device, for example, a desktop, laptop, aterminal such as a thin client, and the like.

The client system 102 will generally have a processor which may beconnected to a display for displaying a graphical user interface (GUI)106 containing the tree model. The client system 102 can also have akeyboard, and one or more input devices, such as a mouse or touchscreen. The client system 102 can have other units operatively coupledto the processor, including one or more tangible, machine-readablestorage media, such as a storage system for the long-term storage ofoperating programs and data, including the programs and data used inexemplary embodiments of the present techniques. Further, the clientsystem 102 can have one or more other types of tangible,machine-readable media, for example, read-only memory (ROM), randomaccess memory (RAM), or hard drives in a storage system. In exemplaryembodiments, the client system 102 may include a network interfaceadapter, for connecting the client system 102 to the server 104.

The server 104 may provide the client system access to the storagenetwork 100. In some exemplary embodiments, the storage network 100 maybe a local area network (LAN), a wide-area network (WAN), or anothernetwork configuration. The server may also include tangible,machine-readable media, such as a storage system for the long-termstorage of operating programs and data, including the programs and dataused in exemplary embodiments of the present techniques.

The server 104 may be communicatively coupled to a plurality of treesources 108. As used herein, the term “tree source” refers to anyphysical or virtual storage device that handles a hierarchical tree ofstorage objects. For example, the tree source 108 may be a storage areanetwork (SAN), network attached storage (NAS), hard disk, redundantarray of inexpensive disks (RAID), a disk drive, a drive partition, aflash drive, and the like. Each tree source 108 provides treeinformation to the server 104 regarding the hierarchy of storage objects110 accessible through the tree source 108.

Each tree source 108 may handle a hierarchy of storage objects 110,which are labeled in FIG. 1 as “A,” “B,” “C,” “D,” and “E”. The storageobjects 110 may be physical devices, virtual devices, or a combinationthereof. For example, the storage objects 110 may include virtual diskdrives, RAID partitions, root directories, file folders, data tables,and the like. Each storage object may store various files and documents,for example, images, video, audio, text documents, applications, and thelike. The tree sources 108 and the storage objects 110 may be used tostore data, and may be referred to as “nodes.” Each tree source 108 maybe referred to as a “root node.” Furthermore, in some embodiments, thetree source 108 may include more than one root node. For purposes of thepresent description, a “parent” node is a node that is higher in thetree hierarchy relative a lower or “child” node and includes the childnode. A “child” node is a node that is lower in the tree hierarchyrelative to a parent node and is accessible through the parent node.Each node may have respective parent nodes and child nodes. Each treesource 108 may send tree information to the server 104 regarding therespective tree source and its child nodes, as discussed below.

The server 104 may receive tree information from the tree sources 108and generate a hierarchical tree model that represents the nodesincluded in the storage network 100. The tree information may includeall of the information about the storage network that may be displayedon the GUI 106 of the client system 102, for example, the names of filesand folders, the hierarchical structure of the tree, and other detailsabout the files or folders such as size, date modified, file type, andthe like. The tree model may include some or all of the tree informationreceived from the tree sources 108.

In exemplary embodiments, only those nodes that are actively viewed by aclient system 102 may be represented in the tree model. Relevant partsof the tree may be communicated to the client system 102 to enable theclient system 102 to retrieve and store files to the network andmanipulate the tree model, such as by adding or removing file folders.To generate the tree model, the server 102 may include a tree integrator112 which generates a tree table. The term “tree table” refers to thetable of tree information that is used to determine the currently viewedstructure of the storage tree and whether a particular node in the treehas changed. In some exemplary embodiments, the tree sources 108 areregistered in a distributed registry, and the tree integrator 104accesses the distributed registry to determine the name and location ofall the available tree sources 108. The distributed registry may beavailable locally to each server 104 included in the network 100. Insome embodiments, the distributed registry may also be available locallyon the client 102. The server 104 may register an available tree source108 to a local discovery component, which may be stored on a tangiblemachine-readable medium included in the server 104. The local discoverycomponent may distribute that registration to all other members of thediscovery group, including the client 102, and other servers in thenetwork 100. A client 102 may access a particular tree source 108 byperforming a lookup on its local discovery component, which may containentries from the discovery group. Each discovery component may havevarious algorithms that enable it find other discovery components on alocal and wide area network.

The tree integrator 112 receives tree information from the tree sources108 to generate an initial tree table, as discussed below. As variousclient systems 102 access additional parts of the storage network 100,the tree integrator 112 may obtain tree information from child nodes ofthe tree sources 108 and add those nodes to the tree table. The servermay use the expanded tree table to generate the tree model. The server104 may send the tree model to the client system 102 to be displayed inthe GUI 106. As discussed above, the network 100 may include a pluralityof servers 104. In such embodiments, the tree integrator 112 may beincluded in only one of the servers 104. Furthermore, the server 104that includes the tree integrator 112 may or may not include a treesource 108.

To keep the tree model updated, each node may be associated with treeinformation packets, referred to herein as a “node cookies” 114 and a“child cookies” 116. As the tree source 108 makes changes to the storagenetwork 100, the tree source 108 may also change the node cookies 114and child cookies 116 to provide an indication to the tree integrator104 that some part of the storage network 100 may have changed. Thecookies 114 and 116 may be any sequence of characters that uniquelyidentify the state of the node. For example, the cookies 114 and 116 mayinclude an integer value, which may be incremented for each change, ahash value derived from attributes of the nodes, a time sequences,random numbers, and the like.

The node cookies 114 may be used to indicate that the respective nodehas changed, for example, files for folders have been added or deleted.Accordingly, if a node is changed, the respective node cookie for thatnode may also be changed. The child cookie 116 may be used to indicatethat one or more of a node's child nodes have changed. Accordingly, ifany of the node's child nodes are changed, the child cookie of therespective node will also be changed. For example, if a new file issaved to a particular node, that node's node cookie may be incrementedto indicate a change in that node. Additionally, the child cookie in thenode's parent nodes may also be incremented to indicate a change in achild node of the parent.

In some exemplary embodiments, the node cookies and child cookies may bestored on the respective node to which the cookie is associated. Inother exemplary embodiments, some or all of the node cookies and childcookies may be stored on the server 104 or the respective tree source108. Techniques for generating a tree table of the network 100 may bebetter understood with reference to FIGS. 2-4.

FIG. 2 is a process flow diagram of a method of generating the storagetree model, in accordance with exemplary embodiments of the presentinvention. The method is generally referred to by the reference number200 and may begin at block 202, wherein the tree integrator 112 obtainsthe initial tree structure by obtaining information for each of the treesources 108 from the distributed registry. For example, the treeintegrator 112 may obtain basic information from each of the treesources from the distributed registry, such as the tree source name,icon, node cookie and child cookie. Using this information, the treeintegrator 112 may generate the initial tree table. An exemplary initialtree table is discussed below with reference to FIG. 3.

After generating the initial tree model, the method 200 of FIG. 2 mayadvance to block 204, wherein the server 104 receives an indication toview the contents of a node. When a user of the client system 102chooses to view the contents of a node such as by opening a foldercorresponding with the node, the tree table and tree model may expand toinclude the child nodes. Accordingly, the client system 102 may registera viewing registration for the node with the server 104. The viewingregistration indicates to the server 104 that one of its client systems102 is actively viewing the contents of that node. Conversely, when aclient system 102 closes a node, the client system 102 unregisters thenode with the server 104, indicating that the client system 102 is nolonger actively viewing the contents of the node.

Next, at block 206, the server 104 adds the registered nodes to the treemodel or removes unregistered nodes from the tree model. Upon adding anew node to the tree model, the tree integrator 112 may add the node tothe tree table, as discussed further with respect to FIG. 4.

FIG. 3 is a graphical representation of an initial tree table, inaccordance with exemplary embodiments of the present invention. The treetable of FIG. 3 represents the initial tree table that may be generatedby the tree integrator 112, before the client system 102 has viewed thecontents of one of the tree sources 108. Based on the tree table of FIG.3, the server 104 may obtain tree information from the tree sources 108to generate a tree model that includes the three tree sources 108, butno child nodes such as the storage objects 110.

As shown in FIG. 3, the initial tree table may include data for each ofthe tree sources 108, such as the current node cookie, current childcookie, prior node cookie, prior child cookie, depth of the node withinthe tree table, and the node's parent node, which for the tree sources108 may be null. Differences between the current cookies and the priorcookies may provide an indication to the server 104 that the respectivenode or child node has changed. For example, the prior cookies mayrepresent the state of the tree model from the perspective of the treeintegrator 112, and the current cookies may represent the state of thetree model from the perspective of the tree source 108. The treeintegrator 112 may store the prior cookies in a tangiblemachine-readable medium included, for example, on the server 104.Periodically, or by when triggered by events, the tree integrator 112may retrieve the current cookies from each of the tree sources 108. Amismatch between the prior cookies and current cookies may indicate achange in the storage network 100 and may trigger the tree integrator112 to update the relevant portion of the tree model. After updating thetree model, the updated tree model may be sent to the client system 102.

FIG. 4 is a graphical representation of the tree table after additionalnodes have been accessed by the client, in accordance with exemplaryembodiments of the present invention. As shown in FIG. 4, the clientsystem 102 has chosen to view the contents of tree source 1 (nodes A, B,C). Additionally, the client system has chosen to view the child nodesof node C (nodes D and E). Accordingly, the root node labeled “treesource 1” and node C both have viewing registrations registered with theserver 104. Accordingly, nodes A-E have been added to the tree table bythe tree integrator 112. In exemplary embodiments of the presentinvention, the server 104 may use the tree table to determine whichnodes to include in the tree model. For example, the server 104 maygenerate a tree model that includes each tree source 108 and eachstorage object 110 whose parent node has a viewing registration. It willbe appreciated that the nodes in the tree table of FIG. 4 may have beenadded to the tree table as a result of receiving viewing registrationsfrom a plurality of client systems 102 which may be viewing differentparts of the storage network 100.

Additionally, the server 104 may also use the tree table to update thetree model. For each registered node, the server 104 will send events tothe client system 102 each time that the node or one of its children haschanged. The events sent to the client system 102 from the server 104may cause the client system 102 to receive an updated view of the treemodel. Conversely, when a client system 102 closes a node, the clientsystem 102 unregisters the node with the server, in which case, theclient server 102 may stop receiving events for that node. Additionally,when all viewing registrations for a node have been removed the treeintegrator 112 may remove the nodes from the tree table and the server104 may remove node from the tree model. Thus, the server 104 may nolonger keep the node and its children updated in the tree model. Methodsof keeping the tree model updated may be better understood withreference to FIG. 5.

FIG. 5 is a process flow diagram of a method of updating the storagetree model, in accordance with exemplary embodiments of the presentinvention. The method is generally referred to by the reference number500 and may begin at block 502, wherein one of the tree sources 108detects a change in one of its nodes. In exemplary embodiments, a nodechange may include any change to the data stored at the node or one ofthe node's child nodes. For example, a node change may include theaddition or deletion of a file, a change of the node or one of thenode's files, the addition or deletion of a node, and the like.

In exemplary embodiments of the present invention, detection of nodechanges may be performed by the tree sources 108 rather than the server104. Methods of detecting changes may depend on the characteristics ofthe physical device represented by the tree source 108. In someembodiments, the tree source 108 may periodically analyze the portion ofthe storage network 100 corresponding to the tree source 108 to detectdifferences, for example, file changes and the like. In otherembodiments, the storage objects 110 may provide change flags or eventsthat inform the tree source 108 that the storage network 108 haschanged. In this way, system resource requirements (CPU, network,communications, memory) of maintaining the entire tree model in memory,or polling for changes, are isolated to the single tree source 108 thatinterfaces with the storage objects 110. Thus, the computing demands onhigher levels of the system such as the server 104 may be reduced. Insome embodiments, a change flag or event may be generated by a physicaldevice, such as a disk drive. In other embodiments, the change flag orevent may be generated by software, for example, the GUI 106, anapplication programming interface (API), and the like.

When the tree source 108 detects a change in one of its nodes, includingthe root node, for example, tree source 108, the tree source 108 sendsthe tree integrator 112 an event that notifies the tree integrator 112that a change in the tree has occurred. The tree integrator 112 mayupdate the tree table, starting at block 504. In other exemplaryembodiments, the tree table and the tree model may be updatedperiodically and block 502 may be eliminated.

At block 504, the tree integrator 112 receives the current node cookieand current child cookie for each of the root nodes that have a viewingregistration. As stated above, changes to a node or a child node mayalso result in a change to the cookies of that node. Thus, a change inthe cookies of the root node may trigger an update of that node in thetree model. Furthermore, if a child cookie has changed, then the treeintegrator 112 may recursively descend through the lower levels of thestorage network 100 and update the tree model until it finds a childcookie that hasn't changed. For purposes of the present description, theterm “present node” describes the node that is currently being analyzedby the tree integrator 112. The present node may start as one of theroot nodes, for example, one of the tree sources 108.

At block 506, the current node cookie and the prior node cookie of thepresent node are compared to determine whether the present node haschanged. If the current node cookie and the prior node cookie aredifferent, the method 500 advances to block 508, wherein the server 104receives updated tree information for the present node. For example, theserver 104 may obtain file names and details, folder names, subfoldernames, and the like. The updated information is saved to the tree modeland the server 104 sends an event to the client server 102 indicatingthat one of the nodes visible to the client 102 has changed. Forexample, referring to FIG. 5, the current and prior node cookies fornode A do not match. Accordingly, in this example, the server 104 mayupdate node A in the tree model and send an event to the client server102 indicating that node A has changed. The method 500 then advances toblock 510. If the current node cookie and the prior node cookie are thesame, the method 500 skips block 508 and advances to block 510.

At block 510, the current child cookie and the prior child cookie of thepresent node are compared to determine whether any of the present node'schild nodes have changed. If the current child cookie and prior childcookie match for the present node, the process flow may advance to block514, wherein the tree integrator 112 may advance to an adjacent node.The adjacent node may be any node that is at the same or higher level inthe tree model compared to the present node. For example, the adjacentnode may be another root node.

If the current child cookie and the prior child cookie are different,the process flow of method 500 advances to block 512, wherein the treeintegrator 112 receives node information for all of the node's childnodes. If any of the child node's current node cookies are differentfrom the child node's prior node cookies, the server 104 receivesupdated tree information for that child node. The updated treeinformation is saved to the tree model and the server 104 sends an eventto the client system 102 indicating that a child node has changed. Ifnew nodes are added or nodes are deleted, events may be sent to theclient system 102 indicating these changes to the tree model. Next, theprocess flow may advance to block 516, wherein the tree integrator 112advances to one of the child nodes of the present node.

After sending the relevant events to the client system 102, the processflow of method 500 returns to step 506, wherein the current and priornode cookies are compared for the next node. In other words, the presentnode becomes the node that the tree integrator advanced to in blocks 514or 516. In this way, the method 500 may be applied recursively as itdescends the tree model from the root node. The method 500 may beapplied for each node that has an active viewing registration.

In exemplary embodiments of the present invention all of the events sentfrom the server 104 to the client 102 may be sent as they are generated.In some exemplary embodiments, the events may be bundled intotransaction units that include several events. For example, the clientsystem 102 may make a blocking call to a “getEvents” method that doesnot return until the server 104 obtains events for that client system102. After the actively viewed nodes have been updated, the tree tablewill also be updated to reflect that each node has been updated and isnow current. In one exemplary embodiment, the prior node cookies andprior child cookies will be set the same value as the respective currentnode cookies and current child cookies.

FIG. 6 is graphical representation of the tree table of FIG. 3 aftersome nodes have been changed, in accordance with exemplary embodimentsof the present invention. As shown in FIG. 6, tree source 1 and nodes A,C, and E have changed. In this example, node A itself has changed, forexample, a file may have been added to the node, thus the node cookiehas been incremented from one to two. Furthermore, node E has changed,thus the node cookie for node E has been incremented from one to two andthe child cookie of node E's parent node, node C, has been incrementedfrom one to two. Further, the child cookie of the parent node of node Aand node E, tree source 1, has been incremented twice, once for thechange to node A and once for node E. Thus, the child cookie of treesource 1 has been incremented from one to three. Using the updatedcookie information, the tree integrator 112 may compare the currentcookies and the prior cookies to determine which nodes of the tree modelto update.

FIG. 7 is a block diagram showing a tangible, machine-readable mediumthat stores code adapted to facilitate the segmentation of Web content,in accordance with an exemplary embodiment of the present invention. Thetangible, machine-readable medium is generally referred to by thereference number 700. The tangible, machine-readable medium 700 cancomprise RAM, a hard disk drive, an array of hard disk drives, anoptical drive, an array of optical drives, a non-volatile memory, a USBdrive, a DVD, a CD, and the like. In one exemplary embodiment of thepresent invention, the tangible, machine-readable medium 700 can beaccessed by a processor 702 over a computer bus 704.

The various software components discussed herein can be stored on thetangible, machine-readable medium 700 as indicated in FIG. 7. Forexample, a first block 706 on the tangible, machine-readable medium 600may store viewing request receiver. The viewing request receiver mayobtain a viewing registration from a client system 102 indicating thatthe client system 102 is actively viewing the requested node. A secondblock 708 can include a tree model generator adapted to add nodes fromthe storage tree to the tree model based on the viewing requestsreceived from the client systems. A third block 710 can include an eventgenerator adapted to send an even to the client system when a node haschanged if the client system has a viewing registration for the node.The tangible, machine-readable medium 700 may also include othersoftware components, for example, a tree table generator that is used todetermine which nodes are being viewed and whether nodes of the storagetree have changed. Although shown as contiguous blocks, the softwarecomponents can be stored in any order or configuration. For example, ifthe tangible, machine-readable medium 700 is a hard drive, the softwarecomponents can be stored in non-contiguous, or even overlapping,sectors.

What is claimed is:
 1. A method of generating a representation of astorage network, comprising: generating a tree model representation of astorage network, the tree model comprising a plurality of nodes, whereineach node represents a portion of the storage network currently beingdisplayed on a display device; receiving a request from a client systemto view contents of a node in the tree model; in response to therequest, obtaining tree information for the node in the request, thetree information related to an additional portion of the storage networknot being displayed; adding an additional node to the tree model basedon the tree information and displaying the additional portion of thestorage network that is represented by the additional node.
 2. Themethod of claim 1, further comprising identifying a root node via aregistry and adding the root node to an initial tree model.
 3. Themethod of claim 2, further comprising receiving an indication from theroot node that indicates that one or more of the root node's child nodeshave changed.
 4. The method of claim 1, wherein obtaining the requestfrom the client system to view the contents of the node comprisesreceiving a viewing registration from the client system.
 5. The methodof claim 1, comprising sending at least a portion of the tree model tothe client system based on which nodes of the tree model have viewingregistrations from the client system.
 6. The method of claim 1,comprising receiving a first cookie corresponding to the node and addingthe node and the first cookie to a tree table.
 7. The method of claim 6,comprising receiving a second cookie corresponding to the node andcomparing the second cookie with the first cookie to determine whetherthe node or one of the node's child nodes has changed.
 8. The method ofclaim 1, comprising sending an event to the client system to indicatethat the tree model has changed, wherein the event causes the client toreceive an updated tree model.
 9. The method of claim 1, comprisingobtaining a request from the client system to close the additional nodein the tree model and, in response to the request, removing theadditional node from the tree model so that the additional portion ofthe storage network that is represented by the additional node is nolonger displayed.
 10. A storage network, comprising: a processor that isadapted to execute machine-readable instructions; a storage device thatis adapted to store data, the data comprising a memory device thatstores instructions that are executable by the processor, theinstructions comprising: a tree model generator to generate arepresentation of a storage network, the tree model comprising aplurality of nodes, wherein each node represents a portion of thestorage network currently being displayed on a display device; and aviewing request receiver to receive a viewing request from a clientsystem to view contents of a node in the tree model; in response to theviewing request, the tree model generator is to: obtain tree informationfor the node in the request, the tree information related to anadditional portion of the storage network not being displayed; and addan additional node to the tree model based on the tree information anddisplay the additional portion of the storage network that isrepresented by the additional node.
 11. The storage network of claim 10,wherein the machine-readable instructions comprise an event receiverconfigured to receive an indication from a tree source indicating thatthe node has changed.
 12. The storage network of claim 10, wherein themachine-readable instructions comprise an event generator configured tosend an indication to the client that a portion of the tree model haschanged.
 13. The storage network of claim 10, wherein the instructionscomprise a tree integrator configured to generate a tree tablecorresponding to a viewed portion of the storage network, the tree tableadapted to provide an indication that the node has changed.
 14. Thestorage network of claim 10, wherein the node is associated with aninformation packet adapted to determine whether the node has changed.15. The storage network of claim 14, wherein the information packetcomprises a node cookie and a child cookie, the node cookie isincremented if the node changes, and the child cookie is incremented ifthe child node has changed.
 16. The storage network of claim 13, whereinthe tree table comprises a data entry for a prior node cookie, a currentnode cookie, a prior child cookie and a current node cookie.
 17. Thestorage network of claim 11, wherein the tree source comprises a RAIDarray.
 18. The storage network of claim 10, wherein the instructions arestored on a central server and wherein the central server sends aportion of the tree model to a client system.
 19. A tangible,computer-readable medium, comprising code configured to direct aprocessor to: generate a tree model representation of a storage network,the tree model comprising a plurality of nodes, wherein each noderepresents a portion of the storage network currently being displayed ona display device; receive a viewing request from a client to view a nodeof the storage network; in response to the viewing request, obtain treeinformation for the node in the viewing request, the tree informationrelated to an additional portion of the storage network not beingdisplayed; and add an additional node to the tree model based on thetree information and display the additional portion of the storagenetwork that is represented by the additional node.
 20. The tangible,computer-readable medium of claim 19, comprising code configured todirect the processor to generate a tree table comprising the node and adata set adapted to indicate whether the node or a child of the node haschanged.